import javax.xml.soap.Node;
import java.util.*;

/**
 * \* Created with IntelliJ IDEA.
 * \* User: Administrator
 * \* Date: 2022/3/3
 * \* Time: 9:28
 * \* To change this template use File | Settings | File Templates.
 * \* Description:
 * \
 */
public class TestDemo {
    /**
     * 求的是出现次数最多的单词
     * @param words
     * @param k
     * @return
     */

    public List<String> topKFrequent(String[] words, int k) {
        HashMap<String,Integer> map = new HashMap<>();

        //1.统计每个单词出现的次数
        for(String s : words){
            if(map.get(s) == null){
                map.put(s,1);
            }else {
                int val = map.get(s);
                map.put(s,val+1);
            }
        }

        //2.建立一个大小为K的小根堆
        PriorityQueue<Map.Entry<String,Integer>> minHeap = new PriorityQueue<>(new Comparator<Map.Entry<String, Integer>>() {
            @Override
            public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
                return o1.getValue() - o2.getValue();
            }
        });

        //3.遍历map
        for(Map.Entry<String,Integer> entry :map.entrySet()){
            if(minHeap.size() < k){
                minHeap.offer(entry);
            }else{
                //说明堆中已经放慢了K个元素，需要看堆顶元素的数据，和当前数据的大小关系
                Map.Entry<String,Integer> top = minHeap.peek();
                //判断频率是否相同，如果相同，比较单词大小，单词小的入堆
                if(top.getValue().compareTo(entry.getValue() )== 0){
                    if (top.getKey().compareTo(entry.getKey()) > 0){
                        minHeap.poll();
                        minHeap.offer(entry);

                    }
                }else {
                    if (top.getValue().compareTo(entry.getValue()) > 0){
                        minHeap.poll();
                        minHeap.offer(entry);
                }
            }
        }
            System.out.println(minHeap);

            List<String> ret = new ArrayList<>();
            return null;

    }




    //旧键盘

    public static void func(String strExce,String strAactual){
        HashSet<Character> set = new HashSet<>();
        for(char ch:strAactual.toUpperCase().toCharArray()){
            set.add(ch);
        }

        HashSet<Character> broken = new HashSet<>();
        for(char ch: strExce.toUpperCase().toCharArray()){
            if(!set.contains(ch) && !broken.contains(ch)){
                System.out.print(ch);
                broken.add(ch);
            }
        }
    }


    public static int singleNumber(int[] nums) {
        Map<Integer,Integer> map = new HashMap<>();
        for (int i:nums){
            if(map.containsKey(i)){
                map.put(i,map.get(i)+1);
            }
            map.put(i,1);
        }
        for (Map.Entry<Integer,Integer>entry : map.entrySet()){
            if (entry.getValue()==1) return entry.getKey();
        }
        return -1;
    }

    public static int singleNumber1(int[] nums) {
        HashSet<Integer> set = new HashSet<>();
        for(int x:nums){
            if (set.contains(nums[x])){
                set.remove(nums[x]);
            }else {
                set.add(nums[x]);
            }
        }
        for (int x:nums){
            if (set.contains(nums[x])){
                return x;
            }
        }
        return -1;
    }


//给定10w个数据，统计每个数据出现的次数
    public static Map<Integer,Integer> func1(int[] array){
        //key是关键字，value是出现的次数
        Map<Integer,Integer> map = new HashMap<>();
        //判断array中的元素，是否在map当中，如果不在就是1，否则在原来的基础+1
        for (int x:array) {
            if(map.get(x) == null){
                map.put(x,1);
            }else{
                int val = map.get(x);
                map.put(x,val+1);
            }
        }
        return map;
    }

    //将10w个数据去重
    //直接把数据放到set中
    public static Set<Integer> func2(int[] array){
        HashSet<Integer> set = new HashSet<>();
        for(int x: array){
            set.add(x);
        }
        return set;
    }

    //从10w个数据中，找出第一个重复的数据
    //每次把元素放到set里，放之前检查一下set中是不是已存在
    public static int func3(int[] array){
        HashSet<Integer> set = new HashSet<>();
        for(int x: array){
            if(set.contains(x)){
                return x;
            }
            set.add(x);
        }
        return -1;
    }

    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        while(scanner.hasNextLine()){
            String str1 = scanner.nextLine();
            String str2 = scanner.nextLine();
            func(str1,str2);
        }
    }

    public static void main5(String[] args) {
        int []array = {1,2,2,5,4,5,4};
        System.out.println(singleNumber(array));
    }

    public static void main4(String[] args) {
        int [] array  = new int[1_00];
        Random random = new Random();
        for (int i = 0; i < array.length; i++) {
            array[i] = random.nextInt(100);
        }
        Map <Integer,Integer> map=func1(array);
        System.out.println(map);
    }




    public static void main3(String[] args) {
        Set<String> s = new TreeSet<>();
        // add(key): 如果key不存在，则插入，返回ture
        // 如果key存在，返回false
        boolean isIn = s.add("apple");
        s.add("orange");
        s.add("peach");
        s.add("banana");
        System.out.println(s.size());//打印结果：4
        System.out.println(s);//打印结果：[apple, banana, orange, peach]
        isIn = s.add("apple");
        // add(key): key如果是空，抛出空指针异常
        //s.add(null);
        // contains(key): 如果key存在，返回true，否则返回false
        System.out.println(s.contains("apple"));//打印结果：true
        System.out.println(s.contains("watermelen"));//打印结果：false
       // remove(key): key存在，删除成功返回true
      // key不存在，删除失败返回false
     // key为空，抛出空指针异常
        s.remove("apple");
        System.out.println(s);//打印结果：[banana, orange, peach]
        s.remove("watermelen");
        System.out.println(s);//打印结果：[banana, orange, peach]
      // 抛出空指针异常
      // s.remove(null);
        Iterator<String> it = s.iterator();
        while(it.hasNext()){
            System.out.print(it.next() + " ");//打印结果：banana orange peach
        }
        System.out.println();

    }


    public static void main2(String[] args) {
        Set<Integer> set = new HashSet<>();
        set.add(1);
        set.add(3);
        set.add(1);
        System.out.println(set);
    }



    public static void main1(String[] args) {
        Map<String ,Integer> map = new HashMap<>();
        map.put("abc",3);
        map.put("dog",2);
        map.put("cat",4);
        System.out.println(map);
        Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
        //调出来的时候用一个for循环就可以了
        for (Map.Entry<String, Integer> entry: entrySet) {
            System.out.println(entry.getKey() + "->" +entry.getValue());
        }


       // Set<String> set = map.keySet();
       // System.out.println(set);

       /* System.out.println(map);
        int ret = map.get("abc");//通过key来获取对应的value值
        System.out.println(ret);
       // int ret1 = map.get("abc1");//通过key来获取对应的value值
       // System.out.println(ret1);//没有这个元素，将会空指针异常
        System.out.println(map.get("abc1"));//这样写的话，如果没有则会给一个默认值null
        System.out.println(map.getOrDefault("abc1",100));//如果没有，则给一个默认值100
        Integer ret2 = map.remove("dog");
        System.out.println(ret2);
        System.out.println(map);
*/
    }
}
